<template>
	<dam-page>
		<dam-scroll-page ref="danScrollRef" :headerHeight="toolbarH + 'px'" footer-height="100px" :scrollEnable="true"
			:isFixZIndex="true" @scrollToLower="scrollToLower" @scroll="scroll" :isAnimation="isAnimation">
			<template #header>
				<comp-chat-header @left-click="onLeftClick" @right-click="onRightClick"></comp-chat-header>
			</template>
			<view :class="messages.length > 0 ? '' : 'v_content'" @touchstart="handleTouchStart"
				@touchmove="handleTouchMove" @touchend="handleTouchEnd">
				<comp-message-list v-if="messages.length > 0" :messages="messages" :isLoading="isLoading"
					@reSend="reSend" />
				<comp-welcome v-else />
			</view>
		</dam-scroll-page>

		<comp-chat-input class="chat-input" :isLoading="isLoading" :inputText="inputText" :models="models"
			:selectedModel="selectedModel" @send-message="sendMessage" @update:selectedModel="upSelectedModel"
			@update:inputText="val => inputText = val" @stopSend="stopSend"></comp-chat-input>

		<uv-popup ref="chatListRef">
			<view class="chat-list">
				<comp-chat-list :chatList="chatList" :currectChat="HISTORY_KEY"
					@switch-chat="onSelectChat"></comp-chat-list>
			</view>
		</uv-popup>

		<transition name="fade">
			<view class="right" v-if="!isLower && isShowUpper" @click="toBottom">
				<span class="icon-send iconfont bs-send"></span>
			</view>
		</transition>

	</dam-page>
</template>

<script lang="ts" setup>
/**
* ------------------------------
* 依赖导入与组件注册
* ------------------------------
*/
import { ref, onMounted, nextTick } from 'vue';
import { onLoad } from '@dcloudio/uni-app';
import { getAbilityExector, printLog } from '@/dam_uni_frame/utils/DamApi';
import { storeToRefs } from 'pinia';
import { usePageStore } from "@/dam_uni_frame/stores/stores";
import ThemeColorUtil from "@/jzutils/ThemeColorUtil";
import ThemeLangUtil from "@/jzutils/ThemeLangUtil";
import openaiService from '@/api/openaiService';
import functions from '@/api/function.js';
import { functionDefinitions } from '@/api/functionDefinitions.js';

import CompChatHeader from './comps/comp-chat-header.vue';
import CompMessageList from './comps/comp-message-list.vue';
import CompWelcome from './comps/comp-welcome.vue';
import CompChatList from './comps/comp-chat-list';
import CompChatInput from './comps/comp-chat-input.vue';

/**
 * ------------------------------
 * 页面相关状态管理
 * ------------------------------
 */
const pageStore = usePageStore();
const { toolbarH } = storeToRefs(pageStore);

// 添加全局日志开关
const DEBUG = true;

// 添加全局日志函数
function debugLog(type, ...args) {
	if (!DEBUG) return;
	const timestamp = new Date().toISOString();
	switch (type) {
		case 'log':
			console.log(`[${timestamp}]`, ...args);
			break;
		case 'info':
			console.info(`[${timestamp}]`, ...args);
			break;
		case 'warn':
			console.warn(`[${timestamp}]`, ...args);
			break;
		case 'error':
			console.error(`[${timestamp}]`, ...args);
			break;
	}
}

/**
 * ------------------------------
 * OpenAI 实例初始化
 * ------------------------------
 */

// const API_BASE = 'http://chat.jinzhong.com.cn';
const AUTH_TOKEN = uni.getStorageSync('token');

/**
 * ------------------------------
 * 组件内部响应式变量定义
 * ------------------------------
 */
const danScrollRef = ref<any>(null); // 滚动组件引用
const messages = ref<Array<Message>>([]); // 聊天记录
const inputText = ref(''); // 输入框内容
const models = ref([
	{ label: '基础模型 (更适用于数据查询)', value: 'qwen-plus' },
	{ label: '深度思考', value: 'deepseek-r1-250120' },
]);
const selectedModel = ref('qwen-plus'); // 默认选中的模型
const isLoading = ref(false); // 加载状态
const abortController = ref<AbortController | null>(null);
const chatListRef = ref()
const isLower = ref(true)
const isShowUpper = ref(false)
const isAnimation = ref(false)
// 本地存储的 key 定义
const HISTORY_KEY = ref('chat_1741156189558');
const chatList = ref([])

/**
 * ------------------------------
 * 生命周期钩子
 * ------------------------------
 */
onMounted(() => {
	debugLog('info', '组件挂载开始');
	// 确保chatList始终是数组格式
	chatList.value = uni.getStorageSync('chatList') || [];
	debugLog('log', '当前聊天列表:', chatList.value);

	// 初始化第一个聊天会话（如果为空）
	if (chatList.value.length === 0) {
		debugLog('info', '创建首个聊天会话');
		const newChatKey = generateChatKey();
		chatList.value.push(newChatKey);
		uni.setStorageSync('chatList', chatList.value);
		HISTORY_KEY.value = newChatKey;
		initializeNewChat(newChatKey);
		debugLog('log', '新会话创建完成:', newChatKey);
	} else {
		HISTORY_KEY.value = chatList.value[chatList.value.length - 1];
		debugLog('log', '使用最后一个会话:', HISTORY_KEY.value);
	}

	// 加载当前聊天记录
	loadHistory();
	danScrollRef.value.scrollToBottom();
	isLower.value = true;
	debugLog('info', '组件挂载完成');
});

onLoad((options) => {
	if (options.type === 'recommend') {
		debugLog('info', '推荐聊天开始');
		// 设置推荐消息并延迟发送
		setTimeout(() => {
			inputText.value = '小灵，给我推荐一个设备吧';
			sendMessage();
		}, 500);
	}
})

// 生成唯一聊天key（时间戳格式）
const generateChatKey = () => {
	return `chat_${Date.now()}`;
};

// 初始化新聊天存储结构
const initializeNewChat = (key: string) => {
	uni.setStorageSync(key, {
		messages: [],
		createdAt: new Date().toISOString(),
		lastActive: Date.now()
	});
};
/**
 * ------------------------------
 * 事件处理函数
 * ------------------------------
 */

function onLeftClick() {
	chatListRef.value.open('left');
	const chatList = uni.getStorageSync('chatList') || [];
	chatList.forEach((key, index) => {
		console.log(`${index + 1}. ${key}`);
		const chatData = uni.getStorageSync(key);
		console.log(`  创建时间：${chatData?.createdAt || '未知'}`,
			`最后活跃：${chatData?.lastActive ? new Date(chatData.lastActive).toLocaleString() : '从未'}`);
	});
}

function onRightClick() {
	stopSend()
	setTimeout(() => {
		// 生成唯一key（时间戳方案）
		const newChatKey = generateChatKey();

		// 清除所有历史聊天记录
		chatList.value.forEach(key => {
			uni.removeStorageSync(key);
		});

		// 只保留当前新建的聊天
		chatList.value = [newChatKey];
		uni.setStorageSync('chatList', chatList.value);

		// 初始化新对话存储空间
		initializeNewChat(newChatKey);

		// 切换到新对话
		HISTORY_KEY.value = newChatKey;

		// 清空当前消息和输入框
		messages.value = [];
		inputText.value = '';

		console.log(`已创建新对话并清除所有历史聊天记录：${newChatKey}`);
		danScrollRef.value.scrollToBottom();
	}, 150)
}

function onSelectChat(key) {
	stopSend()
	setTimeout(() => {
		isShowUpper.value = false
		HISTORY_KEY.value = key;
		loadHistory();
		danScrollRef.value.scrollToBottom();
		chatListRef.value.close();
	}, 150)

}

/**
 * 发送消息主函数
 * 协调整个消息发送流程，包括用户消息添加、AI响应获取和错误处理
 */
async function sendMessage() {
	debugLog('info', '开始发送消息');
	debugLog('log', '当前输入内容:', inputText.value);
	debugLog('log', '当前加载状态:', isLoading.value);

	isLower.value = true;
	abortController.value = new AbortController();

	// 若输入为空或正在加载则直接返回
	if (!inputText.value.trim() || isLoading.value) {
		debugLog('warn', '消息发送被阻止：', !inputText.value.trim() ? '输入为空' : '正在加载中');
		return;
	}

	try {
		debugLog('info', '准备发送消息流程');
		// 添加用户消息并准备UI
		await addUserMessage();
		debugLog('log', '用户消息已添加');

		// 添加AI消息占位
		addAiMessagePlaceholder();
		debugLog('log', 'AI消息占位已添加');

		// 设置加载状态
		isLoading.value = true;
		debugLog('log', '加载状态已设置');

		debugLog('info', '开始处理流式响应');
		// 调用公共服务处理流式响应
		await processStreamResponse();
		debugLog('log', '流式响应处理完成');

		debugLog('info', '保存聊天记录');
		// 更新完成后保存聊天记录
		saveHistory();
		debugLog('log', '聊天记录已保存');
	} catch (error) {
		debugLog('error', '消息发送过程出错:', error);
		handleApiError(error);
	} finally {
		debugLog('info', '完成消息处理');
		finishMessageProcessing();
	}
}

/**
 * 添加用户消息到聊天界面
 */
async function addUserMessage() {
	const userMessage = {
		role: 'user',
		content: inputText.value,
		timestamp: new Date().toLocaleTimeString(),
		usage: null,
		streaming: true
	};
	messages.value.push(userMessage);

	// 确保 Vue 处理 DOM 之后再滚动
	await nextTick();
	danScrollRef.value.scrollToBottom();
	saveHistory();
	inputText.value = '';
}

/**
 * 添加AI消息占位符
 */
function addAiMessagePlaceholder() {
	const aiMessage = {
		role: 'assistant',
		content: '',
		timestamp: '',
		usage: null,
		streaming: true,
		thinking: false, // 初始化思考状态为false
		thinking_text: '' // 初始化思考状态文本为空字符串
	};
	messages.value.push(aiMessage);
	danScrollRef.value.scrollToBottom();
}

/**
 * 处理API流式响应
 */
async function processStreamResponse() {
	debugLog('info', '开始处理流式响应');

	// 使用封装的openaiService处理流式响应
	await openaiService.streamChatCompletion({
		messages: getContextMessages(),
		model: selectedModel.value,
		signal: abortController.value.signal,

		// 处理文本内容块
		onChunk: async (content, chunk) => {
	// 更新当前 AI 消息内容
		const lastMessage = messages.value[messages.value.length - 1];
			
			// 只有当最后一条消息是助手消息时才处理内容
			if (lastMessage && lastMessage.role === 'assistant') {
				// 如果是第一次接收到内容，清除思考状态
				if (lastMessage.thinking) {
					lastMessage.thinking = false;
					lastMessage.thinking_text = '';
					debugLog('log', '接收到文本内容，清除思考状态');
				}
		
		// 根据选择的模型类型处理内容
		if (selectedModel.value === 'deepseek-r1-250120') {
			// 深度思考模型
			if (content.includes('</think>')) {
				// 如果遇到结束标签,将之前的内容作为思考过程,之后的内容作为正文
				const parts = content.split('</think>');
				
				// 添加思考过程
				if (parts[0]) {
					lastMessage.reasoning_content = (lastMessage.reasoning_content || '') + parts[0].replace(/<think>/, '');
				}
				
				// 添加正文内容
				if (parts[1]) {
					lastMessage.content = (lastMessage.content || '') + parts[1];
				}
				
				// 标记已经遇到了</think>标签
				lastMessage.thinkEnded = true;
			} else if (lastMessage.thinkEnded) {
				// 如果已经遇到过</think>标签,所有内容都添加到正文
				lastMessage.content = (lastMessage.content || '') + content;
			} else {
				// 还没有遇到过</think>标签,所有内容添加到思考过程
				lastMessage.reasoning_content = (lastMessage.reasoning_content || '') + content;
			}
		} else {
			// 基础模型,所有内容都是正文
			lastMessage.content = (lastMessage.content || '') + content;
		}
		
		lastMessage.timestamp = new Date().toLocaleTimeString();
				
				// 更新调试日志
				debugLog('log', '接收流式内容:', content);
			} else if (lastMessage && lastMessage.role === 'tool') {
				// 如果最后一条是工具消息，可能需要创建新的助手消息
				const newAssistantMessage = {
					role: 'assistant',
					content: content,
					timestamp: new Date().toLocaleTimeString(),
					streaming: true,
					thinking: false // 确保新消息没有思考状态
				};
				messages.value.push(newAssistantMessage);
				debugLog('log', '工具调用后创建新的助手消息:', content);
	}

	// 自动滚动到底部
	if (isLower.value) {
		danScrollRef.value.scrollToBottom();
	}
		},

		// 工具调用开始处理
		onToolCallStarted: async () => {
			debugLog('info', '工具调用开始，添加状态提示');

			// 确保最后一条消息是助手消息
		const lastMessage = messages.value[messages.value.length - 1];
			if (lastMessage && lastMessage.role === 'assistant') {
				// 添加思考状态提示
				lastMessage.thinking = true;
				lastMessage.thinking_text = '思考分析中...';
			}

			// 滚动到底部
			if (isLower.value) {
				await nextTick();
	danScrollRef.value.scrollToBottom();
			}
		},

		// 所有工具调用完成
		onToolCallFinished: async (allResults) => {
			debugLog('info', '所有工具调用完成，准备最终回复');

			// 确保最后一条消息是助手消息
			const lastMessage = messages.value[messages.value.length - 1];
			if (lastMessage && lastMessage.role === 'assistant') {
				// 更新思考状态
				lastMessage.thinking = true;
				lastMessage.thinking_text = '正在整理答案...';
			}

			// 滚动到底部
			if (isLower.value) {
				await nextTick();
				danScrollRef.value.scrollToBottom();
			}
		},

		// 处理工具调用
		onToolCall: (deltaToolCalls, toolCalls) => {
			debugLog('log', '处理工具调用:', deltaToolCalls);

			// 获取当前助手消息，如果已经有工具调用则更新，否则创建新的
			let lastMessage = messages.value[messages.value.length - 1];
			if (lastMessage.role !== 'assistant') {
				// 如果最后一条消息不是助手消息，可能是因为在多轮工具调用中
				// 添加一个新的助手消息
				lastMessage = {
					role: 'assistant',
					content: '',
					timestamp: new Date().toLocaleTimeString(),
					streaming: true
				};
				messages.value.push(lastMessage);
			}

			// 过滤有效的工具调用
			const validToolCalls = toolCalls.filter(tc => tc !== null);

			// 只有在有有效工具调用时才添加tool_calls属性
			if (validToolCalls.length > 0) {
				lastMessage.tool_calls = [...validToolCalls];
			}
		},

		// 处理工具调用结束
		onToolCallEnd: async (toolCalls, results) => {
			debugLog('log', '工具调用结束，处理结果:', results);
			
			// 标记最后一条消息中的工具调用已执行
	const lastMessage = messages.value[messages.value.length - 1];
			if (lastMessage && lastMessage.role === 'assistant') {
				lastMessage.tool_calls_executed = true;
				// 清除思考状态，因为工具调用已完成
				lastMessage.thinking = false;
				lastMessage.thinking_text = '';
			}
			
			// 添加工具调用结果作为新消息
			results.forEach(result => {
				// 确保工具调用结果内容不包含AI的回复内容
				// 有时API会错误地将AI回复附加到工具调用结果中
				let resultContent = result.content;
				
				// 尝试解析JSON，检查是否为纯工具调用结果
				try {
					const parsed = JSON.parse(resultContent);
					// 确认是合法的工具结果格式
					if (parsed && (parsed.status || parsed.data)) {
						// 使用原始内容
						messages.value.push({
							role: 'tool',
							tool_call_id: result.tool_call_id,
							content: resultContent,
							timestamp: new Date().toLocaleTimeString()
						});
						debugLog('log', '添加工具调用结果（纯JSON）:', result.tool_call_id);
					}
				} catch (e) {
					// 如果无法解析为JSON，可能包含了AI回复
					// 尝试分离工具调用结果和AI回复
					const jsonEndIndex = resultContent.indexOf('"}') + 2;
					if (jsonEndIndex > 1 && jsonEndIndex < resultContent.length - 1) {
						// 分离工具调用结果和AI回复
						const toolResult = resultContent.substring(0, jsonEndIndex);
						const aiResponse = resultContent.substring(jsonEndIndex).trim();
						
						// 添加工具调用结果
		messages.value.push({
			role: 'tool',
							tool_call_id: result.tool_call_id,
							content: toolResult,
			timestamp: new Date().toLocaleTimeString()
		});
						debugLog('log', '添加分离后的工具调用结果:', result.tool_call_id);
						
						// 如果有AI回复内容，添加为新的助手消息
						if (aiResponse) {
							messages.value.push({
								role: 'assistant',
								content: aiResponse,
								timestamp: new Date().toLocaleTimeString(),
								streaming: true
							});
							debugLog('log', '从工具结果中提取并添加AI回复为新消息:', aiResponse);
						}
					} else {
						// 无法分离，使用原始内容
	messages.value.push({
		role: 'tool',
							tool_call_id: result.tool_call_id,
							content: resultContent,
		timestamp: new Date().toLocaleTimeString()
	});
						debugLog('log', '添加无法分离的工具调用结果:', result.tool_call_id);
					}
				}
			});
			
			// 添加一个新的空助手消息，等待下一轮流式输出
			// 只有当最后一条消息不是助手消息时才添加
			const currentLastMessage = messages.value[messages.value.length - 1];
			if (currentLastMessage.role !== 'assistant') {
				messages.value.push({
					role: 'assistant',
					content: '',
					timestamp: new Date().toLocaleTimeString(),
					streaming: true,
					thinking: false // 确保新消息没有思考状态
				});
				debugLog('log', '工具调用结束后添加新的空助手消息，准备接收流式输出');
			}
			
			// 清除所有助手消息的思考状态
			// 确保在多轮工具调用中没有任何旧的思考状态残留
			messages.value.forEach(msg => {
				if (msg.role === 'assistant' && msg.thinking) {
					msg.thinking = false;
					msg.thinking_text = '';
				}
			});
			
			// 自动滚动到底部
			if (isLower.value) {
				danScrollRef.value.scrollToBottom();
				saveHistory(); // 保存中间状态的聊天记录
			}
		},

		// 处理错误
		onError: (error) => {
			debugLog('error', '流式响应处理出错:', error);
			handleApiError(error);
		},

		// 处理完成
		onFinish: (result) => {
			debugLog('log', '整个会话完成，结果:', result);
			
			// 清除所有助手消息的思考状态
			messages.value.forEach(msg => {
				if (msg.role === 'assistant' && msg.thinking) {
					msg.thinking = false;
					msg.thinking_text = '';
				}
			});
			
			// 将模型的最终响应添加为助手消息
			// 此时所有工具调用和推理都已完成
			if (messages.value.length > 0) {
				// 获取最后一条助手消息索引
				const lastAssistantIndex = messages.value.findLastIndex(msg => msg.role === 'assistant');
				
				if (lastAssistantIndex >= 0) {
					const lastAssistantMessage = messages.value[lastAssistantIndex];
					
					// 如果有工具消息，检查最后一条工具消息是否包含AI回复
					const lastToolIndex = messages.value.findLastIndex(msg => msg.role === 'tool');
					if (lastToolIndex > lastAssistantIndex && lastToolIndex < messages.value.length) {
						const lastToolMessage = messages.value[lastToolIndex];
						// 尝试提取可能包含在工具消息中的AI回复
						try {
							// 解析JSON，检查是否为纯工具调用结果
							JSON.parse(lastToolMessage.content);
							// 如果能成功解析，说明是纯工具结果，不需要处理
						} catch (e) {
							// 可能包含AI回复
							const jsonEndIndex = lastToolMessage.content.indexOf('"}') + 2;
							if (jsonEndIndex > 1 && jsonEndIndex < lastToolMessage.content.length - 1) {
								// 分离工具调用结果和AI回复
								const aiResponse = lastToolMessage.content.substring(jsonEndIndex).trim();
								
								if (aiResponse) {
									// 将AI回复从工具消息中移除
									lastToolMessage.content = lastToolMessage.content.substring(0, jsonEndIndex);
									
									// 创建新的助手消息，以保持时间顺序
									messages.value.push({
										role: 'assistant',
										content: aiResponse,
										timestamp: new Date().toLocaleTimeString(),
										streaming: false,
										thinking: false // 确保新消息没有思考状态
									});
									debugLog('log', '从工具消息中提取并添加为新的AI回复:', aiResponse);
								}
							}
						}
					}
					
					// 标记最后一条助手消息为非流式状态
					lastAssistantMessage.streaming = false;
					
					// 清除思考状态
					if (lastAssistantMessage.thinking) {
						lastAssistantMessage.thinking = false;
						lastAssistantMessage.thinking_text = '';
						debugLog('log', '清除最后一条助手消息的思考状态');
					}
					
					// 如果最后一条助手消息没有内容，但结果中有内容，则更新它
					if ((!lastAssistantMessage.content || lastAssistantMessage.content.trim() === '') && result && result.content) {
						// 使用模型返回的最终内容更新空的助手消息
						lastAssistantMessage.content = result.content;
						debugLog('log', '更新空的AI回复内容:', result.content);
					}
					
					// 如果仍然没有内容，添加默认回复以防止空消息
					if (!lastAssistantMessage.content || lastAssistantMessage.content.trim() === '') {
						lastAssistantMessage.content = "已完成操作";
						debugLog('log', '添加默认回复，防止空消息');
					}
				} else {
					// 如果没有找到助手消息，创建一个新的
					if (result && result.content) {
		messages.value.push({
			role: 'assistant',
							content: result.content,
			timestamp: new Date().toLocaleTimeString(),
							streaming: false,
							thinking: false // 确保新消息没有思考状态
						});
						debugLog('log', '添加新的AI回复消息:', result.content);
					} else {
						// 如果没有结果内容，添加默认回复
		messages.value.push({
			role: 'assistant',
							content: "已完成操作",
			timestamp: new Date().toLocaleTimeString(),
							streaming: false,
							thinking: false // 确保新消息没有思考状态
						});
						debugLog('log', '添加默认AI回复消息，因为没有结果内容');
					}
				}
			}
			
			// 确保滚动到底部
			nextTick(() => {
				danScrollRef.value.scrollToBottom();
			});
			
			// 完成所有处理
	isLoading.value = false;
	abortController.value = null;
			saveHistory();
		}
	});
}

/**
 * ------------------------------
 * 本地存储操作
 * ------------------------------
 */
// 保存聊天记录到本地存储
function saveHistory() {
	debugLog('info', '开始保存聊天记录');
	const historyData = {
		messages: messages.value,
		lastActive: Date.now(),
		createdAt: uni.getStorageSync(HISTORY_KEY.value)?.createdAt || new Date().toISOString()
	};

	debugLog('log', '保存的数据:', {
		key: HISTORY_KEY.value,
		messagesCount: messages.value.length,
		lastActive: new Date(historyData.lastActive).toLocaleString()
	});

	try {
		uni.setStorageSync(HISTORY_KEY.value, JSON.stringify(historyData));
		debugLog('info', '聊天记录保存成功');
	} catch (error) {
		debugLog('error', '保存聊天记录失败:', error);
	}
}

// 从本地存储加载聊天记录
function loadHistory() {
	debugLog('info', '开始加载聊天记录');
	try {
		const rawData = uni.getStorageSync(HISTORY_KEY.value);
		debugLog('log', '原始数据:', rawData);

		// 处理空值情况
		if (!rawData) {
			debugLog('warn', '未找到聊天记录，初始化空数组');
			messages.value = [];
			return;
		}

		// 兼容旧数据格式
		const historyData = typeof rawData === 'string' ?
			JSON.parse(rawData) :
			rawData;

		debugLog('log', '解析后的数据:', {
			messagesCount: historyData.messages?.length,
			lastActive: historyData.lastActive
		});

		messages.value = historyData.messages || [];

		// 自动修复旧数据格式
		if (!historyData.lastActive) {
			debugLog('warn', '检测到旧格式数据，进行修复');
			saveHistory();
		}

		debugLog('info', '聊天记录加载完成');
	} catch (e) {
		debugLog('error', '加载历史记录失败:', e);
		messages.value = [];
	}
}

/**
 * ------------------------------
 * 辅助函数：获取上下文消息
 * 保留最近10组问答（不再是原来的3组）
 * ------------------------------
 */
function getContextMessages() {
	// 使用openaiService的方法处理消息
	return openaiService.getContextMessages(messages.value, 10);
}

function upSelectedModel(value: string) {
	selectedModel.value = value;
}

function reSend(content: string, index: number) {
	danScrollRef.value.scrollToBottom();
	isLower.value = true
	messages.value.splice(index);
	saveHistory();
	inputText.value = content;
	setTimeout(() => {
		sendMessage();
	}, 50);
}

function stopSend() {
	debugLog('info', '开始停止发送');
	if (abortController.value) {
		debugLog('log', '中止控制器存在，执行中止操作');
		abortController.value.abort();

		// 立即停止流式输出
		const lastIndex = messages.value.length - 1;
		if (messages.value[lastIndex]?.streaming) {
			debugLog('log', '处理最后一条流式消息');
			setTimeout(() => {
				messages.value[lastIndex] = {
					...messages.value[lastIndex],
					content: "请求已中止",
					streaming: true
				};
				saveHistory();
				debugLog('log', '消息状态已更新');
			}, 100);
		}

		abortController.value = null;
		isLoading.value = false;
		saveHistory();
		debugLog('info', '停止发送完成');
	} else {
		debugLog('warn', '中止控制器不存在，无需操作');
	}
}

function scrollToLower() {
	nextTick(() => {
		danScrollRef.value.scrollToBottom();
		isLower.value = true
	})
}

function scroll() {
	isShowUpper.value = true
}


function toBottom() {
	isAnimation.value = true
	danScrollRef.value.scrollToBottom();
	isLower.value = true
	setTimeout(() => {
		isAnimation.value = false
	}, 1000);
}

let touchStartY = 0
let touchEndY = 0

function handleTouchStart(e) {
	touchStartY = e.touches[0].clientY
}
function handleTouchMove(e) {
	// if (isLoading) {
	// 	 isLower.value = false
	// }
}
function handleTouchEnd(e) {
	touchEndY = e.changedTouches[0].clientY
	const distance = touchEndY - touchStartY
	if (distance > 0) {
		isLower.value = false
	}
}

/**
 * 处理API错误
 * @param {Error} error - 错误对象
 */
function handleApiError(error) {
	if (error.name === 'AbortError') {
		// 已在中止处理中更新状态，无需重复操作
		console.log('用户主动取消请求');
		return;
	}

	console.error('API调用失败:', error);

	// 出错时移除加载中的 AI 消息，并提示错误信息
	messages.value.pop();
	messages.value.push({
		role: 'assistant',
		content: '服务器繁忙，请稍后重试',
		timestamp: new Date().toLocaleTimeString(),
		streaming: false
	});
}

/**
 * 完成消息处理
 */
function finishMessageProcessing() {
	isLoading.value = false;
	abortController.value = null;
	danScrollRef.value.scrollToBottom();
}
</script>


<style scoped lang="scss">
@import "/dam_uni_frame/styles/dam_theme_common.scss";
@import "/static/css/iconfont.css";

.chat-input {
	z-index: 100;
}

.v_content {
	display: flex;
	flex-direction: column;
	align-items: center;
	justify-content: center;
	padding: 20vh 50px 0;
}

.chat-list {
	width: 80vw;
	z-index: 2000;
}

.to-lower {
	background: #d2e6ff;
	color: #3c9cff;
	width: 30px;
	height: 30px;
	border-radius: 50%;
	text-align: center;
	align-items: center;
	justify-content: center;
	display: flex;
	position: fixed;
	bottom: 120px;
	right: 15px;
	font-size: 20px;
	z-index: 100;
}

.right {
	position: fixed;
	bottom: 110px;
	right: 50%;
	transform: translateX(50%);
	padding: 5px;
	background: #d2e6ff;
	/* 注意这里可以不设置 opacity，因为会由过渡类控制 */
	opacity: 0.8;
	height: 35px;
	width: 35px;
	border-radius: 50%;
	display: flex;
	justify-content: center;
	align-items: center;
	animation: 1s infinite alternate to-lower;
}

.icon-send {
	transform: rotate(180deg);
	font-size: 26px;
	color: #3c9cff;
}

.fade-enter-active,
.fade-leave-active {
	transition: opacity 0.5s ease;
}

.fade-enter-from,
.fade-leave-to {
	opacity: 0;
}

.fade-enter-to,
.fade-leave-from {
	opacity: 0.8;
}
</style>